home *** CD-ROM | disk | FTP | other *** search
/ BMUG Revelations / BMUG Revelations.toast / Entertainment / Strategy / Robots / Mech Zone / Sample Robots / Binary 1.4d next >
Encoding:
Text File  |  1991-09-07  |  4.8 KB  |  145 lines  |  [TEXT/KAHL]
  1. ` Binary
  2. ` Uses state-of-the-art binary targeting algorithm. Also pops to top
  3. ` level if target "disappears".
  4.  
  5. ` Changed in v. 1.1: when swiveling to the right, we go 1 degree
  6. ` further than twice the scanwidth. This keeps regions disjoint.
  7.  
  8. ` v. 1.1a3 based directly off of 1.1a. Once the scanwidth is
  9. ` reasonably small, checks to see if has achieved a fortuitous
  10. ` lock.
  11.  
  12. ` v.1.2 Treats its first shot as a "test" for decoys before firing for
  13. ` effect. Also bases tightscan on range using a rough guess based on experiment.
  14.  
  15. ` v.1.3 is same as 1.2 except that tightscan guesses are based on
  16. ` a precise calculation of target's angular width and a notion
  17. ` that a 1/n chance of being lucky is worth taking when you have
  18. ` >=n swivels to go before a "guaranteed" lock.
  19.  
  20. ` v.1.3a is more "greedy". It is based on a notion that a 1/n chance
  21. ` of being luckyis worth taking when you have >= n/2 swivels to go
  22. ` before a guaranteed lock. This is because each swivel is a swival
  23. ` and a ping, i.e. two turns.
  24.  
  25. ` v 1.4 incorporates modifications for dealing with floating point
  26. ` math. (Essentially, this involves changing "=0" to "<1" on one line
  27. ` and making sure another line is rounded properly. (Note that we
  28. ` still haven't tested for the "missing degree" bug, which originally
  29. ` made me find the discontinuous robot bug in RB.) Also fixes a
  30. ` branching error: the program should now initiate tightscan checks
  31. ` earlier when at a close range.
  32.  
  33. ` v 1.4a incorporates an additional floating point correction by
  34. ` changing =0 to <1 in the line before checking for tightscans.
  35.  
  36. ` v 1.4b does a total of three objectscan 0's before starting over.
  37. ` This is slightly wasteful, but much less so than starting over
  38. ` when only 1 degree away from a lock, which the current algorithm
  39. ` allows. Note that the introduction of FP math has introduced a
  40. ` new side effect (as of 8/6/91) in that swivel -0.5 is the same as
  41. ` swivel -1 (provided headfacing isn't 0). To some extent this is an
  42. ` advantage because it *appears* that a target at the extreme left of
  43. ` a scan would otherwise never be found.
  44.  
  45. ` v 1.4c uses TRUNC to do away with the side effect, and compensates
  46. ` by doing the last few objectscans correctly.
  47.  
  48. ` v 1.4d has a fix for tightscan. At ranges greater than 78, tightscan
  49. ` is 8 instead of 16. (Ranges can go up to 106, which I forgot.)
  50.  
  51. equip 4 0 0 0 0 300
  52.  
  53. ` tightscan is the maximum width at which the computer will see
  54. ` if it got lucky. (This requires an extra scan, so it may not be
  55. ` worth it if you only have a rough idea where the enemy is located.)
  56.  
  57. let TRUE = 1
  58. let FALSE = 0
  59. let left = TRUE
  60.  
  61. ` Search 128-degree arcs until a target is located.
  62.  
  63.  
  64. 5 let scanwidth = 64
  65. 7 let swivelamt = 129
  66. 10 objectscan scanwidth
  67. 20 if range > 0 then goto 50
  68. 30 swivel swivelamt
  69. 40 goto 10
  70.  
  71. ` Target found. Are we accurate enough to fire?
  72.  
  73. 50 if scanwidth < 1 then goto 500
  74. 51 let tightscan = 64
  75. 52 if range > 26 then let tightscan = 32
  76. 53 if range > 46 then let tightscan = 16
  77. 54 if range > 78 then let tightscan = 8
  78. 56 if scanwidth > tightscan then goto 100
  79. 57 objectscan 0
  80. 60 if range > 0 then goto 500
  81.  
  82. ` Not accurate enough...
  83. ` Narrow in by scanning left half of known arc.
  84.  
  85. 100 let left = TRUE
  86. 105 let scanwidth = scanwidth / 2
  87. 110 let swivelamt = scanwidth + .5
  88. 115 let swivelamt = TRUNC swivelamt
  89. 117 let swivelamt = 0 - scanwidth
  90. 120 swivel swivelamt
  91. 130 objectscan scanwidth
  92. 140 if range > 0 then goto 50
  93.  
  94. ` Not in left half. If scanwidth is zero, we should only do one or two
  95. ` more scans.
  96.  
  97. 145 if scanwidth < 1 then goto 200
  98.  
  99. ` Otherwise, let's treat the right half as the new known arc.
  100.  
  101. 160 let left = FALSE
  102. 162 let swivelamt = 3 * scanwidth
  103. 165 let swivelamt = swivelamt/2
  104.     let swivelamt = TRUNC swivelamt
  105. 166 let swivelamt = swivelamt + 1
  106. 167 let scanwidth = scanwidth/2
  107. 170 goto 120
  108.  
  109. ` Last scan(s) before starting over. If we find him here, shoot.
  110. ` Otherwise, start over with wide angle scan.
  111.  
  112. 200 swivel 1
  113. 210 objectscan 0
  114. 220 if range > 0 then goto 500
  115. 230 if left = FALSE then goto 5
  116. 240 let left = FALSE
  117. 250 goto 200
  118.  
  119. ` Now scans immediately after the first zap before doing zap zap.
  120. ` Also expends a minimum of energy on the first zap to avoid expending
  121. ` energy on decoys. (Note: we could do a humanscan, but that wouldn't
  122. ` be worth it unless we know there are a lot of humans about. That
  123. ` could be checked at the beginning of the game with a humanscan 180.)
  124. ` Also note that it may not be worth it to cripple the first zap,
  125. ` thus effectively warning the target.
  126.  
  127. ` *Also* checks to see if target is friendly. If so, restarts scan
  128. ` in such a way as to avoid locking on target again. (In practice,
  129. ` robots could inform each other of their locations to avoid confusing
  130. ` each other.)
  131.  
  132. 500 if ENEMY = 0 then goto 600
  133. 501 zap 1
  134. 502 objectscan 0
  135. 503 if range = 0 then goto 5
  136. 505 zap
  137. 507 zap
  138. 510 objectscan 0
  139. 520 if range > 0 then goto 505
  140. 530 goto 5
  141.  
  142. 600 let scanwidth = 64
  143. 610 let swivelamt = 129
  144. 620 goto 30
  145.